home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / C / Applications / Eudora 1.3.1 / source / pop.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-03-16  |  28.2 KB  |  1,129 lines  |  [TEXT/MPS ]
  1. #define FILE_NUM 30
  2. /* Copyright (c) 1990-1992 by the University of Illinois Board of Trustees */
  3. /************************************************************************
  4.  * functions for dealing with a pop 2 server
  5.  ************************************************************************/
  6. #pragma load EUDORA_LOAD
  7. #ifdef    KERBEROS
  8. #include                <krb.h>
  9. #endif
  10. #pragma segment POP
  11.  
  12. typedef enum
  13. {
  14.     user=1, pass, stat, retr, dele, quit, top, list, apop
  15. } POPEnum;
  16.  
  17. #define CMD_BUFFER 514
  18. #define PSIZE (UseCTB ? 256 : 4096)
  19. /************************************************************************
  20.  * private routines
  21.  ************************************************************************/
  22. #ifndef KERBEROS
  23. int POPIntroductions(void);
  24. #else
  25. int POPIntroductions(UPtr hostname);
  26. #endif
  27. int POPByeBye(void);
  28. int POPCmd(int cmd, UPtr args);
  29. int POPCmdGetReply(int cmd, UPtr args, UPtr buffer, long *size);
  30. int StartPOP(UPtr serverName, short port);
  31. int EndPOP(void);
  32. int POPGetMessage(long messageNumber,short *gotSome);
  33. int POPCmdError(int cmd,UPtr args,UPtr message);
  34. int PutOutFromLine(short refN,long *fromLen);
  35. int DupHeader(short refN,UPtr buff,long bSize,long offset,long headerSize);
  36. int SplitAndSave(short refN,long estSize);
  37. int WritePartLine(short refN,short partNo);
  38. short DoBody(short refN,long headerSize,long origOffset,char *buf,long bSize,Boolean abomination,long estSize);
  39. int Prr;
  40. Boolean PopConnected;
  41. int FirstUnread(int count);
  42. Boolean HasBeenRead(short msgNum,short count);
  43. void StampPartNumber(MSumPtr sum,short part,short count);
  44. UPtr ExtractStamp(UPtr stamp,UPtr banner);
  45. Boolean GenDigest(UPtr banner,UPtr secret,UPtr digest);
  46.  
  47. /************************************************************************
  48.  * public routines
  49.  ************************************************************************/
  50. /************************************************************************
  51.  * GetMyMail - the biggie; transfers mail into In mailbox
  52.  ************************************************************************/
  53. short GetMyMail(Boolean quietly)
  54. {
  55. #pragma unused(quietly)
  56.     int messageCount;
  57.     int message,first;
  58.     Str255 scratch;
  59.     Str255 msgname;
  60.     Str63 hostName;
  61.     short port;
  62.     short gotSome = 0;
  63.     TOCHandle tocH;
  64.     short err;
  65.     
  66.     GetPOPInfo(msgname,hostName);
  67.     port = GetRLong(POP_PORT);
  68.     if (StartPOP(hostName,port)==noErr)
  69.     {
  70. #ifdef    KERBEROS
  71.         messageCount = POPIntroductions(hostName);
  72. #else
  73.         messageCount = POPIntroductions();
  74. #endif
  75.         if (messageCount>0 && !Prr)
  76.         {
  77.             ComposeLogR(LOG_RETR,nil,START_POP_LOG,hostName,port,messageCount);
  78.             if (tocH=GetInTOC())
  79.             {
  80.                 for (first=message=PrefIsSet(PREF_DONT_DELETE) ?
  81.                                                                                         FirstUnread(messageCount) : 1;
  82.                             message<=messageCount;
  83.                             message++)
  84.                 {
  85.                     ComposeRString(msgname,POP_STATUS_FMT,
  86.                                                     message-first+1,messageCount-first+1);
  87.                     Progress(0,msgname);
  88.                     (*tocH)->dirty = True;
  89.                     if (POPGetMessage(message,&gotSome)) break;
  90.                 }
  91.             }
  92.             else
  93.                 Prr = 1;
  94.         }
  95.     }
  96.     if (AttachedFiles) SetHandleBig(AttachedFiles,0);
  97.     err = Prr;
  98.     EndPOP();
  99.     
  100. #ifndef KERBEROS
  101.     if (PrefIsSet(PREF_SAVE_PASSWORD) && *Password &&
  102.         (!EqualString(Password,GetPref(scratch,PREF_PASS_TEXT),True,True) ||
  103.          !EqualString(SecondPass,GetPref(scratch,PREF_AUXPW),True,True)))
  104.     {
  105.         ChangeStrn(PREF_STRN,PREF_PASS_TEXT,Password);
  106.         ChangeStrn(PREF_STRN,PREF_AUXPW,SecondPass);
  107.         UpdateResFile(SettingsRefN);
  108.     }
  109. #endif
  110.     return(gotSome);
  111. }
  112.  
  113. /************************************************************************
  114.  * POPrror - see if there was a POP error
  115.  ************************************************************************/
  116. int POPrror(void)
  117. {
  118.     return(Prr);
  119. }
  120.     
  121. /************************************************************************
  122.  * private routines
  123.  ************************************************************************/
  124. /************************************************************************
  125.  * StartPOP - get connected to the POP server
  126.  ************************************************************************/
  127. int StartPOP(UPtr serverName, short port)
  128. {
  129.     PopConnected=False;
  130.     Prr=ConnectTrans(serverName,port,False);
  131.     return(Prr);
  132. }
  133.  
  134. /************************************************************************
  135.  * EndPOP - get rid of the POP server
  136.  ************************************************************************/
  137. int EndPOP()
  138. {
  139.     SilenceTrans(True);
  140.     if (!Prr && !CommandPeriod)
  141.     {
  142.         (void) POPByeBye();
  143.         Prr=DisTrans();
  144.     }
  145.     Prr = DestroyTrans();
  146.     return(Prr);
  147. }
  148.  
  149. #ifdef    KERBEROS
  150.                 /* callback fns kerberos uses to read/write on our connection */
  151. static int            kread(char *buf, int len, void *uptr)
  152. {
  153.                 int err;
  154.                 int ret_len = len;
  155.                 
  156.                 err = TCPRecvTrans((UPtr) buf, &ret_len);
  157.                 if (!err)
  158.                                 return len;
  159.                 else
  160.                                 return 0;
  161.                 }
  162. static int            kwrite(char *buf, int len, void *uptr)
  163. {
  164.                 int err;
  165.  
  166.                 err = TCPSendTrans(1, (UPtr) buf, (int) len);
  167.                 if (!err)
  168.                                 return len;
  169.                 else
  170.                                 return 0;
  171.                 }
  172. #endif
  173.  
  174. /************************************************************************
  175.  * POPIntroductions - sniff the POP server's bottom, and vice-versa
  176.  ************************************************************************/
  177. #ifndef KERBEROS
  178. int POPIntroductions(void)
  179. #else
  180. int POPIntroductions(UPtr hostname)
  181. #endif
  182. {
  183.     Str255 buffer;
  184.     Str63 userName;
  185.     Str255 args;
  186.     long size;
  187.     int result = -1;
  188. #ifdef    KERBEROS
  189.                 int status;
  190.                 KTEXT_ST ticket;
  191.                 long authopts;
  192.                 char name[ANAME_SZ];
  193.                 char instance[INST_SZ];
  194.                 char realm[REALM_SZ];
  195.                 char hname[256];
  196. #else
  197.     Boolean useAPOP = PrefIsSet(PREF_APOP);
  198.     Str255 digest;    
  199. #endif
  200.                 
  201. #ifdef    KERBEROS
  202.                 Progress(NoChange,GetRString(buffer,LOGGING_IN));
  203.                 GetPOPInfo(userName,args);
  204.                 
  205.                 PtoCcpy(hname, hostname);
  206.                 PtoCcpy(name, userName);
  207.                 instance[0] = 0;
  208.                 realm[0] = 0;
  209.                 if(0 != (status = krb_get_lrealm(realm, 1))) {
  210.                                 char        message[256];
  211.                                 
  212.                                 sprintf(message, "Login failed: %s", krb_err_txt[status]);
  213.                                 c2pstr(message);
  214.                                 AlertStr(OK_ALRT,Caution,message);
  215.                                 Prr = '-';
  216.                                 goto done;
  217.                 }
  218.                 
  219.                 authopts = 0L;
  220.                 status = krb_sendauth(authopts, &ticket, "pop", hname, NULL, NULL,
  221.                                                                                                                 NULL, NULL, NULL, NULL, NULL, NULL, NULL, "VERSION9",
  222.                                                                                                                 kread, kwrite, NULL, name, instance, realm);
  223.                 if (status != KSUCCESS) {
  224.                                 char        message[256];
  225.                                 
  226.                                 sprintf(message, "Login failed: %s", krb_err_txt[status]);
  227.                                 c2pstr(message);
  228.                                 AlertStr(OK_ALRT,Caution,message);
  229.                                 Prr = '-';
  230.                                 goto done;
  231.                 }
  232. #endif    
  233.  
  234.     do
  235.     {
  236.         size = sizeof(buffer)-1;
  237.         Prr = RecvLine(buffer+1,&size);
  238.         if (Prr) goto done;
  239.         buffer[0] = MIN(size,127);
  240.         Progress(NoChange,buffer);
  241.     }
  242.     while (buffer[1]!='+' && buffer[1]!='-');
  243.     
  244.     PopConnected = size && (buffer[1]=='+' || buffer[1]=='-');
  245.     if (buffer[1] != '+')
  246.     {
  247.         Prr = buffer[1];
  248.         POPCmdError(-1,nil,buffer);
  249.         goto done;
  250.     }
  251.     
  252.     if (useAPOP) {useAPOP = GenDigest(buffer,Password,digest);}
  253.     
  254. #ifndef KERBEROS
  255.     Progress(NoChange,GetRString(buffer,LOGGING_IN));
  256.     GetPOPInfo(userName,args);
  257. #endif
  258.  
  259.     if (useAPOP)
  260.     {
  261.         size = sizeof(buffer)-1;
  262.         PCopy(args,userName);
  263.         PCatC(args,' ');
  264.         PCat(args,digest);
  265.         Prr = POPCmdGetReply(apop,args,buffer,&size);
  266.     }
  267.     else
  268.     {
  269.         size = sizeof(buffer)-1;
  270.         Prr = POPCmdGetReply(user,userName,buffer,&size);
  271.         if (Prr || *buffer != '+')
  272.         {
  273.             if (!Prr) POPCmdError(user,userName,buffer);
  274.             Prr = '-';
  275.             goto done;
  276.         }
  277.     
  278. #ifndef KERBEROS
  279.         PCopy(args,Password);
  280. #else
  281.         PCopy(args, "\parbitrary");
  282. #endif
  283.     
  284.         size = sizeof(buffer)-1;
  285.         Prr = POPCmdGetReply(pass,args,buffer,&size);
  286.     }
  287.     if (Prr || *buffer != '+')
  288.     {
  289.         if (!Prr)
  290.         {
  291.             POPSecure = False;
  292.             POPCmdError(pass,nil,buffer);
  293. #ifndef KERBEROS
  294.             InvalidatePasswords(False,True);
  295. #endif
  296.         }
  297.         Prr = '-';
  298.         goto done;
  299.     }
  300.     POPSecure = True;
  301.     
  302. #ifndef POPSECURE
  303.     Progress(NoChange,GetRString(buffer,LOOK_MAIL));
  304. #endif
  305.     size = sizeof(buffer)-1;
  306.     Prr = POPCmdGetReply(stat,nil,buffer,&size);
  307.     if (Prr || *buffer != '+')
  308.     {
  309.         if (!Prr)  POPCmdError(stat,nil,buffer);
  310.         Prr = '-';
  311.         goto done;
  312.     }
  313.     
  314.     result = atoi(buffer+3);
  315.     done:
  316.     return(result);
  317. }
  318.  
  319. /************************************************************************
  320.  * POPByeBye - tell the POP server we're leaving
  321.  ************************************************************************/
  322. int POPByeBye(void)
  323. {
  324.     char buffer[CMD_BUFFER];
  325.     long size=sizeof(buffer);
  326.     if (!PopConnected) return(noErr);
  327.     Prr = POPCmdGetReply(quit,nil,buffer,&size);
  328.     return (Prr || *buffer != '+');
  329. }
  330.  
  331. /************************************************************************
  332.  * POPCmd - Send a command to the POP server
  333.  ************************************************************************/
  334. int POPCmd(int cmd, UPtr args)
  335. {
  336.     char buffer[CMD_BUFFER];
  337.  
  338.     GetRString(buffer,POP_STRN+cmd);
  339.     if (args && *args)
  340.         PCat(buffer,args);
  341. #ifdef DEBUG_COMM
  342.     Progress(NoBar,buffer);
  343. #endif DEBUG_COMM
  344.     PCat(buffer,NewLine);
  345.     
  346.     Prr=SendTrans(1,buffer+1,*buffer);
  347.     
  348.     return(Prr);
  349. }
  350.  
  351. /************************************************************************
  352.  * POPCmdGetReply - send a POP command and get a reply
  353.  ************************************************************************/
  354. int POPCmdGetReply(int cmd, UPtr args, UPtr buffer, long *size)
  355. { 
  356.     long rSize;
  357.     if (Prr=POPCmd(cmd,args)) return(Prr);                /* error in transmission */
  358.     do
  359.     {
  360.         rSize = *size;
  361.         Prr = RecvLine(buffer,&rSize);
  362.     }
  363.     while (!Prr && *buffer!='+' && *buffer!='-');
  364.     *size = rSize;
  365.     return(Prr);
  366. }
  367.  
  368. /************************************************************************
  369.  * POPGetMessage - get a message from the POP server
  370.  ************************************************************************/
  371. int POPGetMessage(long messageNumber,short *gotSome)
  372. {
  373.     Str255 args;
  374.     char buffer[CMD_BUFFER];
  375.     long size = sizeof(buffer);
  376.     long msgsize=0;
  377.     char *spot;
  378.     short count;
  379.         
  380.     NumToString((long)messageNumber,args);
  381.     
  382.     if (Prr=POPCmdGetReply(list,args,buffer,&size)) return(Prr);
  383.     if (*buffer != '+')
  384.     {
  385.         Prr = *buffer;
  386.         POPCmdError(list,args,buffer);
  387.         return(Prr);
  388.     }
  389.     strtok(buffer," ");                                                                     /* skip ok */
  390.     strtok(nil," ");                                                                            /* skip message id */
  391.     if (spot=strtok(nil," \n")) msgsize = atoi(spot);         /* read message size */
  392.     
  393.   size = sizeof(buffer);
  394.     if (PrefIsSet(PREF_NO_BIGGIES) && msgsize>GetRLong(BIG_MESSAGE))
  395.     {
  396.       NumToString(GetRLong(BIG_MESSAGE_FRAGMENT),buffer);
  397.         PCatC(args,' ');
  398.         PCat(args,buffer);
  399.         msgsize = -1;    /* let everyone down the line know what's going down */
  400.         Prr = POPCmdGetReply(top,args,buffer,&size);
  401.         NoAttachments = True;    /* don't do BinHex */
  402.     }
  403.     else
  404.     {
  405.       Prr=POPCmdGetReply(retr,args,buffer,&size);
  406.         NoAttachments = False;
  407.     }
  408.     if (Prr) return(Prr);
  409.     if (*buffer!='+')
  410.     {
  411.         POPCmdError(retr,args,buffer);
  412.         return(1);
  413.     }
  414.     BadBinHex = False;
  415.     BeginHexBin();
  416.     if (!AttachedFiles) AttachedFiles=NuHandle(0);
  417.     SetHandleBig(AttachedFiles,0);
  418.     count=POPMessageBody(msgsize);
  419.     SetHandleBig(AttachedFiles,0);
  420.     EndHexBin();
  421.     SaveAbomination(nil,0);
  422.     if (!Prr && !CommandPeriod && !PrefIsSet(PREF_DONT_DELETE) && !NoAttachments &&
  423.         (!BadBinHex || ReallyDoAnAlert(BAD_HEXBIN_ALRT,Stop)==BAD_HEXBIN_IGNORE))
  424.     {
  425.         NumToString(messageNumber,args);
  426.         size = sizeof(buffer);
  427.         Prr=POPCmdGetReply(dele,args,buffer,&size);
  428.     }
  429.  
  430.     if (!Prr) (*gotSome)+=count;
  431.     return(Prr);
  432. }
  433.  
  434. /************************************************************************
  435.  * POPCmdError - report an error for an POP command
  436.  ************************************************************************/
  437. int POPCmdError(int cmd, UPtr args, UPtr message)
  438. {
  439.     Str255 theCmd;
  440.     Str255 theError;
  441.     int err;
  442.  
  443.     GetRString(theCmd,POP_STRN+cmd);
  444.     if (args && *args)
  445.         PCat(theCmd,args);
  446.     strcpy(theError+1,message);
  447.     *theError = strlen(theError+1);
  448.     if (theError[*theError]=='\012') (*theError)--;
  449.     if (theError[*theError]=='\015') (*theError)--;
  450.     MyParamText(theCmd,theError,"\pPOP","");
  451.     err = ReallyDoAnAlert(PROTO_ERR_ALRT,Note);
  452.     return(err);
  453. }
  454.  
  455. /************************************************************************
  456.  * POPMessageBody - read in the body of a message
  457.  ************************************************************************/
  458. int POPMessageBody(long estSize)
  459. {
  460.     UPtr text=nil;
  461.     TOCType **tocH;
  462.     MSumType sum;
  463.     long eof,chopHere;
  464.     Str255 name;
  465.     short count=0,part;
  466.     
  467.     /*
  468.      * make the message summary
  469.      */
  470.     WriteZero(&sum,sizeof(MSumType));
  471.  
  472.     /*
  473.      * grab the "In" box
  474.      */
  475.     if (!(tocH=GetInTOC()))
  476.         return(1);
  477.     PCopy(name,(*tocH)->name);
  478.     
  479.     Prr = BoxFOpen(tocH);
  480.     if (Prr) {FileSystemError(OPEN_MBOX,name,Prr); goto done;}
  481.  
  482.     eof = FindTOCSpot(tocH,estSize);
  483.  
  484.     Prr = SetFPos((*tocH)->refN, fsFromStart, eof);
  485.     if (Prr) {FileSystemError(WRITE_MBOX,name,Prr); goto done;}
  486.         
  487.     count = SplitAndSave((*tocH)->refN,estSize);
  488.     
  489. done:
  490.     if (!Prr && !GetFPos((*tocH)->refN,&chopHere))
  491.         SetEOF((*tocH)->refN,chopHere);
  492.     
  493.     Prr = BoxFClose(tocH) || Prr;
  494.     if (Prr || !count) return(0);
  495.     
  496.     /*
  497.      * now, read it back from the file
  498.      */ 
  499.     if (Prr=OpenLine((*tocH)->vRef,(*tocH)->dirId,name))
  500.          {FileSystemError(READ_MBOX,name,Prr);return(0);}
  501.     if (Prr=SeekLine(eof)) return(FileSystemError(READ_MBOX,name,Prr));
  502.     
  503.     ReadSum(nil,False);
  504.     for (part=1;part<=count;part++)
  505.     {
  506.         Prr = !ReadSum(&sum,False);
  507.         TransLitString(sum.from);
  508.         TransLitString(sum.subj);
  509.         if (!sum.seconds) sum.seconds = GMTDateTime();
  510.         if (count>1) StampPartNumber(&sum,part,count);
  511.         if (Prr || (Prr=!SaveMessageSum(&sum,tocH))) break;
  512.     }
  513.     ReadSum(nil,False);
  514.             
  515.     CloseLine();
  516.     if (Prr)
  517.     {
  518.         WarnUser(READ_MBOX,Prr);
  519.         return(0);
  520.     }
  521.  
  522.     InvalSum(tocH,(*tocH)->count-1);
  523.     if (!PrefIsSet(PREF_CORVAIR))
  524.     {
  525.         Prr = WriteTOC(tocH);
  526.         FlushVol(nil,MyVRef);
  527.     }
  528.     MakeMessTitle(name,tocH,(*tocH)->count-count);
  529.     ComposeLogR(LOG_RETR,nil,MSG_GOT,name,count);
  530.   return(count);
  531. }
  532.  
  533. /************************************************************************
  534.  * SplitAndSave - read a message, (possibly) splitting it into parts and
  535.  * saving it.
  536.  ************************************************************************/
  537. int SplitAndSave(short refN,long estSize)
  538. {
  539.     long origOffset;
  540.     long headerSize;
  541.     long lastProgress=0;
  542.     Str255 buf;
  543.     long size;
  544.     Boolean wasNl = False;
  545.     UPtr writeHere, writeEnd;
  546.     short count=0;
  547.     Str127 abomination;
  548.     Boolean abominable=False;
  549.     Str31 status;
  550.     Boolean foundStatus = False;
  551.     
  552.     if (estSize < 0) GetRString(status,STATUS);
  553.     
  554.     GetRString(abomination,ABOMINATION);
  555.     if (estSize>0) ByteProgress(nil,0,estSize);
  556.     GetFPos(refN,&origOffset);
  557.     
  558.     if (Prr=PutOutFromLine(refN,&headerSize)) return(Prr);
  559.     /*
  560.      * read the header
  561.      */
  562.     for (size=sizeof(buf)-1; !(Prr=RecvLine(buf+1,&size)); size=sizeof(buf)-1)
  563.     {
  564.         writeHere = buf+1;
  565.         writeEnd = writeHere+size-1;
  566.  
  567.         /*
  568.          * check for embedded From lines
  569.          */
  570.         if (IsFromLine(buf+1)){long one=1;(void)FSTabWrite(refN,&one,">");}
  571.         
  572.         /*
  573.          * check for abominations
  574.          */
  575.         if (!striscmp(abomination+1,buf+1)) abominable=True;
  576.         /*
  577.          * progress
  578.          */
  579.         if ((lastProgress+=size) > PSIZE)
  580.         {
  581.             if (estSize) ByteProgress(nil,-lastProgress,0);
  582.             lastProgress = 0;
  583.         }
  584.                 
  585.         /*
  586.          * check for end of message
  587.          */
  588.         if (wasNl && size==2 && buf[1]=='.')
  589.         {
  590.             if (Prr=FSTabWrite(refN,&size,"\n\n")) FileSystemError(WRITE_MBOX,"",Prr);
  591.             goto done;
  592.         }
  593.  
  594.         /*
  595.          * check for escaped periods
  596.          */
  597.         if (wasNl && buf[1]=='.')
  598.             writeHere++;
  599.  
  600.         /*
  601.          * check for continuations, but only if the last "line" ended with
  602.          * a newline; if it didn't, we're just continuing anyway
  603.          */
  604.         if (wasNl)
  605.             if (size>1 && IsWhite(buf[1]))
  606.             {
  607.                 while(IsWhite(*writeHere)) writeHere++; /* skip whitespace */
  608.                 writeHere--;                                        /* well, not ALL of it... */
  609.             }
  610.             else
  611.                 *--writeHere = '\n';        /* we need a newline for the previous line */
  612.         
  613.         /*
  614.          * remove a trailing newline, in case the next line is a continuation
  615.          * (and curse RFC 822)
  616.          */
  617.         if (wasNl= *writeEnd=='\n') writeEnd--;
  618.         
  619.         /*
  620.          * is it a status header?  Do we care?
  621.          */
  622.         if (estSize < 0 && wasNl && !foundStatus && writeHere < writeEnd)
  623.         {
  624.             writeEnd[1] = 0;
  625.             foundStatus = !striscmp(writeHere+1,status+1);
  626.         }
  627.         
  628.         /*
  629.          * now we can write it out...
  630.          */
  631.         size = writeEnd-writeHere+1;
  632.         if (Prr=FSTabWrite(refN,&size,writeHere))
  633.         {
  634.             FileSystemError(WRITE_MBOX,"",Prr);
  635.             goto done;
  636.         }
  637.         
  638.         /*
  639.          * was that the end of the header, by the way?
  640.          */
  641.         if (size==1 && *writeHere=='\n' ||
  642.                 size==2 && *writeEnd=='\n' && *writeHere=='\n')
  643.         {
  644.             size = 1;
  645.             if (Prr=FSTabWrite(refN,&size,"\n"))
  646.             {
  647.                 FileSystemError(WRITE_MBOX,"",Prr);
  648.                 goto done;
  649.             }
  650.             break;
  651.         }
  652.     }
  653.     
  654.     /*
  655.      * at this point, we've saved the header (good for us, eh?)
  656.      * now, go save the body
  657.      */
  658.     GetFPos(refN,&headerSize);
  659.     count=DoBody(refN,headerSize-origOffset,origOffset,buf,sizeof(buf),abominable,estSize);
  660. done:
  661.     return(foundStatus ? 0 : count);
  662. } 
  663.  
  664. /************************************************************************
  665.  * DoBody - read the body of a message from a pop-3 server
  666.  ************************************************************************/
  667. short DoBody(short refN,long headerSize,long origOffset,char *buf,long bSize,Boolean abomination,long estSize)
  668. {
  669.     long writeCount;
  670.     Str63 beginHex;
  671.     UPtr writeHere,writeEnd;
  672.     HexBinStates amHexing = HexDone;
  673.     AbStates snowMan = AbDone;
  674.     Boolean wasNl = True;
  675.     long messageSize=headerSize;
  676.     long lastProgress=0;
  677.     long fragSize=GetRLong(FRAGMENT_SIZE);
  678.     long splitThresh=GetRLong(SPLIT_THRESH);
  679.     long hexOffset;
  680.     short partNo = 0;
  681.     long size;
  682.     long oTicks = TickCount();
  683.  
  684.     GetRString(beginHex,BINHEX);    
  685.     for (size=bSize; !(Prr=RecvLine(buf,&size)); size=bSize)
  686.     {
  687.         writeHere = buf;
  688.         writeEnd = buf + size-1;
  689.         
  690.         /*
  691.          * check for embedded From lines
  692.          */
  693.         if (IsFromLine(buf)){long one=1;(void)FSTabWrite(refN,&one,">");}
  694.         
  695.         /*
  696.          * progress
  697.          */
  698.         if ((lastProgress+=size) > PSIZE)
  699.         {
  700.             if (estSize>0 || amHexing!=HexDone || snowMan!=AbDone)
  701.                 ByteProgress(nil,-lastProgress,0);
  702.             lastProgress = 0;
  703.         }
  704.         
  705.         /*
  706.          * check for end of message
  707.          */
  708.         if (wasNl && size==2 && writeHere[0]=='.') break;
  709.  
  710.         /*
  711.          * check for periods
  712.          */
  713.         if (wasNl && writeHere[0]=='.')
  714.             writeHere++;
  715.             
  716.         /*
  717.          * does this line end in a newline?
  718.          */
  719.         wasNl = *writeEnd=='\n';
  720.         
  721.         /*
  722.          * do some autohexing
  723.          */
  724.         if (!NoAttachments) switch (amHexing)
  725.         {
  726.             case HexDone:
  727.                 if (size>=*beginHex && !strncmp(beginHex+1,writeHere,*beginHex))
  728.                 {
  729.                     amHexing = NotHex;
  730.                     GetFPos(refN,&hexOffset);  /* save binhex start */
  731.                     DontTranslate = True;
  732.                 }
  733.                 break;
  734.             case NotHex:
  735.             case CollectName:
  736.             case CollectInfo:
  737.                 amHexing = SaveHexBin(writeHere,writeEnd-writeHere+1,estSize);
  738.                 if (amHexing>CollectInfo && amHexing!=HexDone)
  739.                 {
  740.                     SetFPos(refN,fsFromStart,hexOffset);    /* toss the saved bits */
  741.                     SetEOF(refN,hexOffset);
  742.                     goto loop;    /* do NOT save the line into the message proper */
  743.                 }
  744.                 break;
  745.             default:
  746.                 amHexing = SaveHexBin(writeHere,writeEnd-writeHere+1,estSize);
  747.                 goto loop;    /* do NOT save the line into the message proper */
  748.         }
  749.         
  750.         if (!NoAttachments && abomination)
  751.             switch(snowMan)
  752.                     
  753.             {
  754.                 case AbDone:
  755.                     if (IsAbLine(writeHere,size))
  756.                     {
  757.                         snowMan = NotAb;
  758.                         GetFPos(refN,&hexOffset);  /* save binhex start */
  759.                         DontTranslate = True;
  760.                     }
  761.                     break;
  762.                 case AbHeader:
  763.                 case AbName:
  764.                     snowMan = SaveAbomination(writeHere,writeEnd-writeHere+1);
  765.                     if (snowMan>AbName && snowMan!=AbDone)
  766.                     {
  767.                         SetFPos(refN,fsFromStart,hexOffset);    /* toss the saved bits */
  768.                         SetEOF(refN,hexOffset);
  769.                         goto loop;    /* do NOT save the line into the message proper */
  770.                     }
  771.                     break;
  772.                 default:
  773.                     snowMan = SaveAbomination(writeHere,writeEnd-writeHere+1);
  774.                     goto loop;    /* do NOT save the line into the message proper */
  775.             }
  776.         
  777.         /*
  778.          * are we over the limit?
  779.          */
  780.         if ((estSize>splitThresh || estSize<messageSize) && messageSize > fragSize)
  781.         {
  782.             Str255 buf2; short b2size=sizeof(buf2);
  783.             writeCount = 1;     /* make sure we have newline */
  784.             if (Prr=FSTabWrite(refN,&writeCount,"\n")) return(Prr);
  785.             if (Prr=DupHeader(refN,buf2,b2size,origOffset,headerSize)) return(Prr);
  786.             /*if (Prr=WritePartLine(refN,++partNo)) return(Prr);*/
  787.             ++partNo;
  788.             messageSize = headerSize;
  789.         }
  790.         
  791.         /*
  792.          * save the data
  793.          */
  794.         writeCount = writeEnd-writeHere+1;
  795.         if (Prr=FSTabWrite(refN,&writeCount,writeHere))
  796.             return(FileSystemError(WRITE_MBOX,"",Prr));
  797.         messageSize += writeCount;
  798.         loop:
  799.             if (amHexing==HexDone && snowMan==AbDone) DontTranslate = False;
  800.     }
  801.     if (!Prr && (writeCount=GetHandleSize(AttachedFiles)))
  802.     {
  803.         Prr=FSTabWrite(refN,&writeCount,LDRef(AttachedFiles));
  804.         UL(AttachedFiles);
  805.     }
  806.     if (!Prr && estSize < 0)
  807.     {
  808.       Str255 msg;
  809.         GetRString(msg,BIG_MESSAGE_MSG);
  810.         writeCount = *msg;
  811.         Prr=FSTabWrite(refN,&writeCount,msg+1);
  812.     }
  813.   if (Prr) return(FileSystemError(WRITE_MBOX,"",Prr));
  814.     Progress(100,nil);
  815.     return(Prr?partNo : partNo+1);
  816. }
  817.  
  818. /************************************************************************
  819.  *
  820.  ************************************************************************/
  821. int WritePartLine(short refN,short partNo)
  822. {
  823.     Str63 partLine;
  824.     long partLen;
  825.     
  826.     ComposeRString(partLine,PART_FMT,partNo);
  827.     partLen = *partLine;
  828.     if (Prr=FSTabWrite(refN,&partLen,partLine+1))
  829.         return(FileSystemError(WRITE_MBOX,"",Prr));
  830.     return(noErr);
  831. }
  832.  
  833. /************************************************************************
  834.  *
  835.  ************************************************************************/
  836. int PutOutFromLine(short refN,long *fromLen)
  837. {
  838.     Str255 fromLine;
  839.     long len;
  840.     
  841.     *fromLen = len = SumToFrom(nil,fromLine);
  842.     if (Prr=FSTabWrite(refN,&len,fromLine))
  843.         return(FileSystemError(WRITE_MBOX,"",Prr));
  844.     return(noErr);
  845. }
  846.  
  847. /************************************************************************
  848.  *
  849.  ************************************************************************/
  850. int DupHeader(short refN,UPtr buff,long bSize,long offset,long headerSize)
  851. {
  852.     long currentOffset;
  853.     long readBytes,writeBytes;
  854.     long copied;
  855.     
  856.     if (Prr=GetFPos(refN,¤tOffset))
  857.         return(FileSystemError(READ_MBOX,"",Prr));
  858.     for (copied=0; copied<headerSize; copied += readBytes)
  859.     {
  860.         if (Prr=SetFPos(refN,fsFromStart,offset+copied))
  861.             return(FileSystemError(READ_MBOX,"",Prr));
  862.         readBytes = bSize < headerSize-copied ? bSize : headerSize-copied;
  863.         if (Prr=FSRead(refN,&readBytes,buff))
  864.             return(FileSystemError(READ_MBOX,"",Prr));
  865.         if (Prr=SetFPos(refN,fsFromStart,currentOffset))
  866.             return(FileSystemError(WRITE_MBOX,"",Prr));
  867.         writeBytes = readBytes;
  868.         if (Prr=FSZWrite(refN,&writeBytes,buff))
  869.             return(FileSystemError(WRITE_MBOX,"",Prr));
  870.         currentOffset += writeBytes;
  871.     }
  872.     return(noErr);
  873. }
  874.  
  875. /************************************************************************
  876.  * FirstUnread - find the first unread message
  877.  *     We do try to be clever about it.  If 
  878.  ************************************************************************/
  879. int FirstUnread(int count)
  880. {
  881.     short first, last, on;
  882.     static short lastCount=0;
  883.     Boolean hasBeen;
  884.     
  885.     on = lastCount;
  886.     lastCount = count;
  887.  
  888. #define SETHASBEEN(o,c)\
  889.     do {hasBeen=HasBeenRead(o,c);if (CommandPeriod) return(c+1);} while (0) 
  890.     if (PrefIsSet(PREF_NO_BIGGIES))
  891.     {
  892.         /* Heuristics */
  893.         if (on && on<=count)
  894.         {
  895.             SETHASBEEN(on,count);
  896.             if (hasBeen)
  897.             {
  898.                 SETHASBEEN(on+1,count);
  899.                 if (!hasBeen) return(on+1);
  900.             }
  901.         }
  902.         SETHASBEEN(count,count);
  903.         if (hasBeen) return(count+1);
  904.         if (count==1) return(1);
  905.         
  906.         /* search... */
  907.         for (on=count-1;on;on--)
  908.         {
  909.             SETHASBEEN(on,count);
  910.             if (hasBeen) break;
  911.         }
  912.         return(on+1);
  913.     }
  914.     else
  915.     {
  916.         first = 1;
  917.         last = count;
  918.         /*
  919.          * try to cut the search short via heuristics
  920.          */
  921.         if (on && on<=count)
  922.         {
  923.             SETHASBEEN(on,count);
  924.             if (hasBeen)
  925.             {
  926.                 if (on<count)
  927.                 {
  928.                     SETHASBEEN(++on,count);
  929.                     if (!hasBeen) return(on);
  930.                 }
  931.                 first = on+1;
  932.             }
  933.             else
  934.                 last = on-1;
  935.         }
  936.         else
  937.         {
  938.             SETHASBEEN(count,count);
  939.             if (hasBeen) return(count+1);
  940.             SETHASBEEN(1,count);
  941.             if (count==1 || !hasBeen) return(1);
  942.             last=count-1;
  943.             first = 2;
  944.             on = count;
  945.             hasBeen = False;
  946.         }
  947.             
  948.         /*
  949.          * hi ho, hi ho, it's off to search we go
  950.          */
  951.         while (first<=last)
  952.         {
  953.             on = (first+last)/2;
  954.             SETHASBEEN(on,count);
  955.             if (hasBeen) first=on+1;
  956.             else last=on-1;
  957.         }
  958.         if (!hasBeen)
  959.             return(on);
  960.         else
  961.             return(on+1);
  962.     }
  963. }
  964.  
  965. /************************************************************************
  966.  * HasBeenRead - has a particular message been read?
  967.  * look for a "Status:" header; if it's "Status: R<something>", message
  968.  * has been read
  969.  ************************************************************************/
  970. Boolean HasBeenRead(short msgNum,short count)
  971. {
  972.     Str127 scratch;
  973.     Boolean unread=False, statFound=False;
  974.     Str31 terminate;
  975.     Str31 status;
  976.     UPtr cp;
  977.     long size;
  978.  
  979.     if (msgNum>count) return(0);
  980.     Progress((msgNum*100)/count,GetRString(scratch,FIRST_UNREAD));
  981.     Pause(60);
  982.     GetRString(terminate,ALREADY_READ);
  983.     GetRString(status,STATUS);
  984.     NumToString(msgNum,scratch);
  985.     PLCat(scratch,1);
  986.     POPCmd(top,scratch);
  987.     for (size=sizeof(scratch);
  988.                 !(Prr=RecvLine(scratch,&size)) &&
  989.                 !(scratch[0]=='.' && scratch[1]=='\n');
  990.                 size=sizeof(scratch))
  991.         if (!unread && !statFound && !striscmp(scratch,status+1))
  992.         {
  993.             statFound = True;
  994.             for (cp=scratch;cp<scratch+size;cp++)
  995.             {
  996.                 if (*cp==':')
  997.                 {
  998.                     for (cp++;cp<=scratch+size-*terminate;cp++)
  999.                         if (!striscmp(cp,terminate+1)) break;
  1000.                     unread = cp> scratch+size-*terminate;
  1001.                     break;
  1002.                 }
  1003.             }
  1004.         }
  1005.     return(statFound && !unread);
  1006. }
  1007.  
  1008. /************************************************************************
  1009.  * StampPartNumber - put the part number on a mail message
  1010.  ************************************************************************/
  1011. void StampPartNumber(MSumPtr sum,short part,short count)
  1012. {
  1013.     char *spot;
  1014.     short i, digits, len;
  1015.     
  1016.     for (i=count,digits=0;i;i/=10,digits++);
  1017.     len = 2*digits+2;
  1018.     spot=sum->subj+MIN(*sum->subj+len,sizeof(sum->subj)-1);
  1019.     *sum->subj = spot-sum->subj;
  1020.     for (i=digits;i;i--,count/=10) *spot-- = '0'+count%10;
  1021.     *spot-- = '/';
  1022.     for (i=digits;i;i--,part/=10) *spot-- = '0'+part%10;
  1023.     *spot = ' ';
  1024. }
  1025.     
  1026. /************************************************************************
  1027.  * AddAttachNote - note that we've attached a file
  1028.  ************************************************************************/
  1029. void AddAttachNote(short wdRef, UPtr name, long creator, long type)
  1030. {
  1031.     Str255 fileAndFolder;
  1032.     Str31 folderName;
  1033.     Str15 typeString, creatorString;
  1034.     
  1035.     BlockMove(&creator,creatorString+1,4);
  1036.     BlockMove(&type,typeString+1,4);
  1037.     *creatorString = *typeString = 4;
  1038.     GetDirName(nil,wdRef,GetMyDirID(wdRef),folderName);
  1039.     ComposeRString(fileAndFolder,FILE_FOLDER_FMT,
  1040.                                  folderName,name,typeString,creatorString);         
  1041.     PtrAndHand(fileAndFolder+1,AttachedFiles,*fileAndFolder);
  1042. }
  1043.  
  1044. /************************************************************************
  1045.  * AddAttachInfo - attach a note about problems with the enclosure
  1046.  ************************************************************************/
  1047. void AddAttachInfo(int theIndex, int result)
  1048. {
  1049.     Str255 theMessage;
  1050.     
  1051.     ComposeString(theMessage,"\p%r%d\n", theIndex, result);
  1052.     PtrAndHand(theMessage+1,AttachedFiles,*theMessage);
  1053. }
  1054.  
  1055.  
  1056. #ifdef POPSECURE
  1057. /************************************************************************
  1058.  * VetPOP - make sure the user's POP account is ok.
  1059.  ************************************************************************/
  1060. short VetPOP(void)
  1061. {
  1062.     Str255 user, host;
  1063.     short port;
  1064.     short err;
  1065.     
  1066.     if (UUPCIn && !UUPCOut) {WarnUser(UUPC_SECURE,0);return(1);}
  1067.     GetPOPInfo(user,host);
  1068.     port = GetRLong(POP_PORT);
  1069. #ifdef DEBUG
  1070.     if (BUG12) port=40110;
  1071. #endif DEBUG
  1072.     if ((err=StartPOP(host,port))==noErr)
  1073.     {
  1074.         (void) POPIntroductions();
  1075.         if (Prr) err=Prr;
  1076.     }
  1077.     EndPOP();
  1078.     if (UseCTB && !err) CTBNavigateSTRN(NAVMID);
  1079.     return(err);
  1080. }
  1081. #endif
  1082.  
  1083. #ifndef KERBEROS
  1084. #pragma segment MD5
  1085. /************************************************************************
  1086.  * GenDigest - generate a digest for APOP
  1087.  ************************************************************************/
  1088. Boolean GenDigest(UPtr banner,UPtr secret,UPtr digest)
  1089. {
  1090.     Str255 stamp;
  1091.     MD5_CTX md5;
  1092.     static char hex[]="0123456789abcdef";
  1093.     short i;
  1094.     
  1095.     if (!*ExtractStamp(stamp,banner)) return(False);
  1096.     
  1097.     MD5Init(&md5);
  1098.     MD5Update(&md5,stamp+1,*stamp);
  1099.     MD5Update(&md5,secret+1,*secret);
  1100.     MD5Final(&md5);
  1101.     
  1102.     for (i=0;i<sizeof(md5.digest);i++)
  1103.     {
  1104.         digest[2*i+1] = hex[(md5.digest[i]>>4)&0xf];
  1105.         digest[2*i+2] = hex[md5.digest[i]&0xf];
  1106.     }
  1107.     digest[0] = 2*sizeof(md5.digest);
  1108.     return(True);
  1109. }
  1110.  
  1111. /************************************************************************
  1112.  * ExtractStamp - grab the timestamp out of a POP banner
  1113.  ************************************************************************/
  1114. UPtr ExtractStamp(UPtr stamp,UPtr banner)
  1115. {
  1116.     UPtr cp1,cp2;
  1117.     
  1118.     *stamp = 0;
  1119.     banner[*banner+1] = 0;
  1120.     if (cp1=strchr(banner+1,'<'))
  1121.         if (cp2=strchr(cp1+1,'>'))
  1122.         {
  1123.             *stamp = cp2-cp1+1;
  1124.             strncpy(stamp+1,cp1,*stamp);
  1125.         }
  1126.     return(stamp);
  1127. }
  1128. #endif
  1129.